package org.example.util.file;

import org.example.util.log.Logac;

import java.io.*;
import java.nio.channels.FileChannel;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.util.ArrayList;
import java.util.List;

/**
 * @auther admin闫
 * @Descriptopn 文件目录操作工具类
 * @date 2024/4/4 18:23
 */
public class FileUtil {


    /**
     * 修改文件名称
     * @param filePath 文件路径
     * @param newName 新名称
     */
    public static void renameFile(String filePath, String newName) {
        File file = new File(filePath);

        if (!file.exists()) {
            System.out.println("文件不存在！");
            return;
        }

        // 获取文件所在目录
        String directory = file.getParent();

        // 构建新的文件路径
        String newFilePath = directory + File.separator + newName;

        // 创建新文件对象
        File newFile = new File(newFilePath);

        // 尝试重命名文件
        if (file.renameTo(newFile)) {
//            System.out.println(filePath+"文件重命名成功！");
        } else {
            Logac.log(filePath+"文件重命名失败！");
        }
    }

    /**
     * 确保文件夹存在，如果不存在则创建。
     *
     * @param folderPath 要检查或创建的[文件夹]路径
     * @return 如果文件夹已存在或成功创建则返回true，否则返回false。
     */
    public static boolean ensureFolderExists(String folderPath) {
        File folder = new File(folderPath);
        if (!folder.exists()) {
            return folder.mkdirs(); // 尝试创建文件夹（包括任何必需的父文件夹）
        }
        return true; // 文件夹已存在
    }

    /**
     *  移动文件到指定的目录下
     * @param sourceFilePath 文件路径
     * @param targetDirectoryPath 目录路径
     */
    public static void moveFile(String sourceFilePath, String targetDirectoryPath) {
        // 将字符串路径转换为Path对象
        Path sourcePath = Paths.get(sourceFilePath);
        Path targetDirectory = Paths.get(targetDirectoryPath);

        try {
            // 使用Files.move()方法来剪切文件
            Path targetPath = Files.move(sourcePath, targetDirectory.resolve(sourcePath.getFileName()));
            System.out.println("文件剪切成功，新位置为: " + targetPath);
        } catch (IOException e) {
            System.err.println("文件剪切失败: " + e.getMessage());
        }
    }


    /**
     * 【根据文件名】获取文件类型
     * @param fileName 文件名
     * @return 文件后缀
     */
    public static String getFileType(String fileName) {
        String[] parts = fileName.split("\\.");
        if (parts.length > 1) {
            return parts[parts.length - 1].toLowerCase(); // 小写化确保不区分大小写
        } else {
            return ""; // 没有后缀名
        }
    }

    /**
     * 根据文件路径获取【文件名】
     * @param path 【文件路径】
     * @param path 【文件路径】
     * @return 【文件名】
     */
    public static String getFileName(String path){
        File file = new File(path);
        String fileName = file.getName();
        return fileName;
    }


    /**
     * 获得指定目录 下一级的【文件夹】
     * @param folderPath 文件路径
     * @return 下级【文件夹】所有的路径集合
     */
    public static List<String> getXiaYiPath(String folderPath) {
        List<String> subfolderPaths = new ArrayList<>();
        File folder = new File(folderPath);

        if (!folder.exists() || !folder.isDirectory()) {
            Logac.log(folderPath + "路径不存在！");
            return subfolderPaths;
        }
        File[] files = folder.listFiles();
        if (files != null) {
            for (File file : files) {
                if (file.isDirectory()) {
                    subfolderPaths.add(file.getAbsolutePath());
                }
            }
        }
        return subfolderPaths;
    }


    /**
     * 获取指定目录 下一级所有【文件】路径
     * @param folderPath 文件路径
     * @return 【文件】路径
     */
    public static List<String> getAllFilePaths(String folderPath) {
        List<String> filePaths = new ArrayList<>();
        File folder = new File(folderPath);

        if (!folder.exists() || !folder.isDirectory()) {
            Logac.log(folderPath + "路径不存在！");
            return filePaths;
        }
        File[] files = folder.listFiles();
        if (files != null) {
            for (File file : files) {
                if (file.isFile()) {
                    filePaths.add(file.getAbsolutePath());
                }
            }
        }
        return filePaths;
    }


    /**
     * 复制文件夹到指定路径。【文件与文件夹都可通用】
     * @param sourceFolderPath 源【文件夹】路径
     * @param destinationFolderPath 目标【文件夹】路径
     * @throws IOException 如果复制过程中出现IO错误
     */
    public static void copyFolder(String sourceFolderPath, String destinationFolderPath) throws IOException {
        File sourceFolder = new File(sourceFolderPath);
        File destinationFolder = new File(destinationFolderPath);

        if (!sourceFolder.exists()) {
            throw new IOException("Source folder does not exist.");
        }

        if (!destinationFolder.exists()) {
            destinationFolder.mkdirs();
        }

        for (String fileName : sourceFolder.list()) {
            File sourceFile = new File(sourceFolder, fileName);
            File destinationFile = new File(destinationFolder, fileName);

            if (sourceFile.isDirectory()) {
                copyFolder(sourceFile.getAbsolutePath(), destinationFile.getAbsolutePath());
            } else {
                copySingleFile(sourceFile, destinationFile);
            }
        }
    }

    /**
     * 复制单个文件到指定路径。
     * @param sourceFilePath 源文件路径
     * @param destinationFilePath 目标文件路径
     * @throws IOException 如果复制过程中出现IO错误
     */
    public static void copyFile(String sourceFilePath, String destinationFilePath) throws IOException {
        File sourceFile = new File(sourceFilePath);
        File destinationFile = new File(destinationFilePath);

        // 确保源文件存在
        if (!sourceFile.exists()) {
            throw new IOException("Source file does not exist.");
        }

        // 创建目标文件所在的目录
        if (destinationFile.getParentFile() != null && !destinationFile.getParentFile().exists()) {
            destinationFile.getParentFile().mkdirs();
        }

        copySingleFile(sourceFile, destinationFile);
    }

    /**
     * 复制单个文件。【私有】
     * @param sourceFile 源文件
     * @param destinationFile 目标文件
     * @throws IOException 如果复制过程中出现IO错误
     */
    private static void copySingleFile(File sourceFile, File destinationFile) throws IOException {
        try (FileChannel sourceChannel = new FileInputStream(sourceFile).getChannel();
             FileChannel destinationChannel = new FileOutputStream(destinationFile).getChannel()) {
            destinationChannel.transferFrom(sourceChannel, 0, sourceChannel.size());
        }
    }

    /**
     * 递归获取目录下所有所有【文件】路径，包含【子目录】
     * @param directoryPath 目录
     * @return 所有路径
     */
    public static List<String> getAllDGFiles(String directoryPath) {
        List<String> filePaths = new ArrayList<>();
        File directory = new File(directoryPath);
        if (!directory.exists()) {
            System.out.println("指定目录不存在。");
            return filePaths;
        }
        getAllFilesRecursive(directory, filePaths);
        return filePaths;
    }

    /**
     * 【私有】 递归调用方法
     * @param directory 目录
     * @param filePaths 目录
     */
    private static void getAllFilesRecursive(File directory, List<String> filePaths) {
        File[] files = directory.listFiles();
        if (files != null) {
            for (File file : files) {
                if (file.isDirectory()) {
                    // 如果是目录，递归调用该方法
                    getAllFilesRecursive(file, filePaths);
                } else {
                    // 如果是文件，将文件路径添加到列表中
                    filePaths.add(file.getAbsolutePath());
                }
            }
        }
    }

    /***
     * 创建文本文件并写入文本
     * @param filePath 文件路径
     * @param content 文本
     */
    public static void createAndWriteToFile(String filePath, String content) {
        try {
            // 创建文件对象
            File file = new File(filePath);
            // 如果文件不存在，则创建文件
            if (!file.exists()) {
                file.createNewFile();
            }
            // 创建 FileWriter 对象
            FileWriter writer = new FileWriter(file);
            // 写入内容到文件
            writer.write(content);
            // 关闭 FileWriter
            writer.close();
            System.out.println("文件已创建并写入内容。");
        } catch (IOException e) {
            e.printStackTrace();
            System.out.println("创建文件失败：" + e.getMessage());
        }
    }

    /**
     * 获取路径的上级文件名
     * @param path 文件路径
     * @return 上级文件名
     */
    public static String shangjFileName(String path){
        // 创建File对象
        File file = new File(path);
        // 获取文件的父目录
        File parentDir = file.getParentFile();
        // 获取父目录的文件名
        String parentDirName = parentDir.getName();
        // 输出结果
        return parentDirName;
    }

    /**
     * 判断【文件】是否存在
     * @param filePath 文件路径
     * @return 是否存在
     */
    public static boolean isFileExists(String filePath) {
        File file = new File(filePath);
        return file.exists();
    }



}
